home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp4.arc / SETPARMB.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-10-08  |  46.9 KB  |  1,441 lines
  1. (*----------------------------------------------------------------------*)
  2. (*        Get_Default_Params --- Set Communications Parameters          *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. OVERLAY PROCEDURE Get_Default_Params( First_Time : BOOLEAN );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Get_Default_Params                                   *)
  10. (*                                                                      *)
  11. (*     Purpose:    Set communications parameters                        *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Get_Default_Params( First_Time );                             *)
  16. (*                                                                      *)
  17. (*           First_Time:  TRUE for initial setup, else FALSE.           *)
  18. (*                                                                      *)
  19. (*      Calls:   ClrScr                                                 *)
  20. (*               Async_Init                                             *)
  21. (*               Async_Open                                             *)
  22. (*               Menu_Get_Choice                                        *)
  23. (*               Menu_Display_Choices                                   *)
  24. (*                                                                      *)
  25. (*      Remarks:                                                        *)
  26. (*                                                                      *)
  27. (*         This routine is called if PIBTERM.CNF doesn't exist,         *)
  28. (*         or to update communications parameters.                      *)
  29. (*                                                                      *)
  30. (*----------------------------------------------------------------------*)
  31.  
  32. VAR
  33.    Settings_Menu   : Menu_Type;
  34.    Settings_Choice : INTEGER;
  35.    I               : INTEGER;
  36.    J               : INTEGER;
  37.  
  38. (*----------------------------------------------------------------------*)
  39. (*          Get_Baud_Rate --- Get Baud Rate for Communications          *)
  40. (*----------------------------------------------------------------------*)
  41.  
  42. OVERLAY PROCEDURE Get_Baud_Rate;
  43.  
  44. CONST
  45.  
  46.    Baud_Rates: ARRAY[ 1 .. 8 ] OF INTEGER
  47.                = ( 110, 150, 300, 600, 1200, 2400, 4800, 9600 );
  48.  
  49. VAR
  50.    Baud_Menu   : Menu_Type;
  51.    I           : INTEGER;
  52.    J           : INTEGER;
  53.  
  54. BEGIN (* Get_Baud_Rate *)
  55.                                    (* Get Baud Rate  *)
  56.    WITH Baud_Menu DO
  57.       BEGIN
  58.  
  59.          Menu_Size    := 8;
  60.          Menu_Row     := 11;
  61.          Menu_Column  := 30;
  62.          Menu_Tcolor  := Menu_Text_Color;
  63.          Menu_Bcolor  := BackGround_Color;
  64.          Menu_Fcolor  := Menu_Frame_Color;
  65.          Menu_Width   := 0;
  66.          Menu_Height  := 0;
  67.  
  68.          CASE Baud_Rate OF
  69.             110 :  Menu_Default := 1;
  70.             150 :  Menu_Default := 2;
  71.             300 :  Menu_Default := 3;
  72.             600 :  Menu_Default := 4;
  73.             1200:  Menu_Default := 5;
  74.             2400:  Menu_Default := 6;
  75.             4800:  Menu_Default := 7;
  76.             9600:  Menu_Default := 8;
  77.          END (* CASE *);
  78.  
  79.       END (* WITH *);
  80.  
  81.    FOR I := 1 TO 8 DO
  82.       WITH Baud_Menu.Menu_Entries[I] DO
  83.       BEGIN
  84.          Menu_Item_Row    := I;
  85.          Menu_Item_Column := 2;
  86.          CASE I OF
  87.             1:  Menu_Item_Text := 'a) 110';
  88.             2:  Menu_Item_Text := 'b) 150';
  89.             3:  Menu_Item_Text := 'c) 300';
  90.             4:  Menu_Item_Text := 'd) 600';
  91.             5:  Menu_Item_Text := 'e) 1200';
  92.             6:  Menu_Item_Text := 'f) 2400';
  93.             7:  Menu_Item_Text := 'g) 4800';
  94.             8:  Menu_Item_Text := 'h) 9600';
  95.          END (* CASE *);
  96.       END;
  97.  
  98.    Baud_Menu.Menu_Title := 'Choose Baud Rate: ';
  99.  
  100.    Menu_Display_Choices( Baud_Menu );
  101.    Baud_Rate := Baud_Rates[ Menu_Get_Choice( Baud_Menu , Erase_Menu ) ];
  102.  
  103. END   (* Get_Baud_Rate *);
  104.  
  105. (*----------------------------------------------------------------------*)
  106. (*        Get_Comm_Port --- Get Port Number for Communications          *)
  107. (*----------------------------------------------------------------------*)
  108.  
  109. OVERLAY PROCEDURE Get_Comm_Port;
  110.  
  111. VAR
  112.    Port_Menu   : Menu_Type;
  113.    I           : INTEGER;
  114.    J           : INTEGER;
  115.  
  116. BEGIN (* Get_Comm_Port *)
  117.                                    (* Get port number           *)
  118.    WITH Port_Menu DO
  119.       BEGIN
  120.  
  121.          Menu_Size    := 2;
  122.          Menu_Default := Comm_Port;
  123.          Menu_Row     := 11;
  124.          Menu_Column  := 30;
  125.          Menu_Tcolor  := Menu_Text_Color;
  126.          Menu_Bcolor  := BackGround_Color;
  127.          Menu_Fcolor  := Menu_Frame_Color;
  128.          Menu_Width   := 0;
  129.          Menu_Height  := 0;
  130.  
  131.       END (* WITH Port_Menu *);
  132.  
  133.    FOR I := 1 TO 2 DO
  134.       WITH Port_Menu.Menu_Entries[I] DO
  135.       BEGIN
  136.          Menu_Item_Row    := I;
  137.          Menu_Item_Column := 2;
  138.          CASE I OF
  139.             1:  Menu_Item_Text := 'a) Serial Port 1';
  140.             2:  Menu_Item_Text := 'b) Serial Port 2';
  141.          END (* CASE *);
  142.       END;
  143.  
  144.    Port_Menu.Menu_Title := 'Which Communications Port: ';
  145.  
  146.    Menu_Display_Choices( Port_Menu );
  147.    I  := Comm_Port;
  148.    Comm_Port := Menu_Get_Choice( Port_Menu , Erase_Menu );
  149.  
  150.                                    (* Remember if port changed *)
  151.  
  152.    Comm_Port_Changed := ( Comm_Port <> I );
  153.  
  154. END   (* Get_Comm_Port *);
  155.  
  156. (*----------------------------------------------------------------------*)
  157. (*            Get_Parity --- Get Parity for Communications              *)
  158. (*----------------------------------------------------------------------*)
  159.  
  160. OVERLAY PROCEDURE Get_Parity;
  161.  
  162. CONST
  163.    Parities:   ARRAY[ 1 .. 3 ] OF Char
  164.                = ( 'E', 'O', 'N' );
  165.  
  166. VAR
  167.    Parity_Menu   : Menu_Type;
  168.    I             : INTEGER;
  169.    J             : INTEGER;
  170.  
  171. BEGIN (* Get_Parity *)
  172.                                    (* Get Parity *)
  173.    WITH Parity_Menu DO
  174.       BEGIN
  175.  
  176.          Menu_Size    := 3;
  177.  
  178.          CASE Parity OF
  179.             'E' :  Menu_Default := 1;
  180.             'O' :  Menu_Default := 2;
  181.             'N' :  Menu_Default := 3;
  182.          END (* CASE *);
  183.  
  184.          Menu_Row     := 11;
  185.          Menu_Column  := 30;
  186.          Menu_Tcolor  := Menu_Text_Color;
  187.          Menu_Bcolor  := BackGround_Color;
  188.          Menu_Fcolor  := Menu_Frame_Color;
  189.          Menu_Width   := 0;
  190.          Menu_Height  := 0;
  191.  
  192.       END (* WITH Parity_Menu *);
  193.  
  194.    FOR I := 1 to 3 DO
  195.       WITH Parity_Menu.Menu_Entries[I] DO
  196.       BEGIN
  197.          Menu_Item_Row    := I;
  198.          Menu_Item_Column := 2;
  199.          CASE I OF
  200.             1:  Menu_Item_Text := 'Even';
  201.             2:  Menu_Item_Text := 'Odd';
  202.             3:  Menu_Item_Text := 'None';
  203.          END (* CASE *);
  204.       END;
  205.  
  206.    Parity_Menu.Menu_Title := 'Choose Parity: ';
  207.  
  208.    Menu_Display_Choices( Parity_Menu );
  209.    Parity := Parities[ Menu_Get_Choice( Parity_Menu , Erase_Menu ) ];
  210.  
  211. END   (* Get_Parity *);
  212.  
  213. (*----------------------------------------------------------------------*)
  214. (*          Get_Stop_Bits --- Get Stop Bits for Communications          *)
  215. (*----------------------------------------------------------------------*)
  216.  
  217. OVERLAY PROCEDURE Get_Stop_Bits;
  218.  
  219. CONST
  220.    Stop_Data:  ARRAY[ 1 .. 2 ] OF INTEGER
  221.                = ( 1 , 2 );
  222.  
  223. VAR
  224.    Stop_Menu   : Menu_Type;
  225.    I           : INTEGER;
  226.    J           : INTEGER;
  227.  
  228. BEGIN (* Get_Stop_Bits *)
  229.                                    (* Get stop bits *)
  230.    WITH Stop_Menu DO
  231.       BEGIN
  232.  
  233.          Menu_Size    := 2;
  234.          Menu_Default := Stop_Bits;
  235.          Menu_Row     := 11;
  236.          Menu_Column  := 30;
  237.          Menu_Tcolor  := Menu_Text_Color;
  238.          Menu_Bcolor  := BackGround_Color;
  239.          Menu_Fcolor  := Menu_Frame_Color;
  240.          Menu_Width   := 0;
  241.          Menu_Height  := 0;
  242.  
  243.       END (* WITH Stop_Menu *);
  244.  
  245.    FOR I := 1 to 2 DO
  246.       WITH Stop_Menu.Menu_Entries[I] DO
  247.       BEGIN
  248.          Menu_Item_Row    := I;
  249.          Menu_Item_Column := 2;
  250.          CASE I OF
  251.             1:  Menu_Item_Text := '1';
  252.             2:  Menu_Item_Text := '2';
  253.          END (* CASE *);
  254.       END;
  255.  
  256.    Stop_Menu.Menu_Title := 'Number of Stop Bits: ';
  257.  
  258.    Menu_Display_Choices( Stop_Menu );
  259.    Stop_Bits := Stop_Data[ Menu_Get_Choice( Stop_Menu , Erase_Menu ) ];
  260.  
  261. END   (* Get_Stop_Bits *);
  262.  
  263. (*----------------------------------------------------------------------*)
  264. (*          Get_Data_Bits --- Get Stop Bits for Communications          *)
  265. (*----------------------------------------------------------------------*)
  266.  
  267. OVERLAY PROCEDURE Get_Data_Bits;
  268.  
  269. CONST
  270.    Char_Bits:  ARRAY[ 1 .. 2 ] OF INTEGER
  271.                = ( 7 , 8 );
  272.  
  273. VAR
  274.    Bits_Menu   : Menu_Type;
  275.    I           : INTEGER;
  276.    J           : INTEGER;
  277.  
  278. BEGIN (* Get_Data_Bits *)
  279.                                    (* Get Bits per Character *)
  280.    WITH Bits_Menu DO
  281.       BEGIN
  282.  
  283.          Menu_Size    := 2;
  284.          Menu_Default := Data_Bits - 6;
  285.          Menu_Row     := 11;
  286.          Menu_Column  := 30;
  287.          Menu_Tcolor  := Menu_Text_Color;
  288.          Menu_Bcolor  := BackGround_Color;
  289.          Menu_Fcolor  := Menu_Frame_Color;
  290.          Menu_Width   := 0;
  291.          Menu_Height  := 0;
  292.  
  293.       END (* WITH Bits_Menu *);
  294.  
  295.    FOR I := 1 to 2 DO
  296.       WITH Bits_Menu.Menu_Entries[I] DO
  297.       BEGIN
  298.          Menu_Item_Row    := I;
  299.          Menu_Item_Column := 2;
  300.          CASE I OF
  301.             1:  Menu_Item_Text := '7';
  302.             2:  Menu_Item_Text := '8';
  303.          END (* CASE *);
  304.       END;
  305.  
  306.    Bits_Menu.Menu_Title := 'Data Bits in Each Character: ';
  307.  
  308.    Menu_Display_Choices( Bits_Menu );
  309.    Data_Bits := Char_Bits[ Menu_Get_Choice( Bits_Menu , Erase_Menu ) ];
  310.  
  311. END   (* Get_Data_Bits *);
  312.  
  313. (*----------------------------------------------------------------------*)
  314. (*        Get_BackSpace --- Get type of Backspace/Delete                *)
  315. (*----------------------------------------------------------------------*)
  316.  
  317. OVERLAY PROCEDURE Get_BackSpace;
  318.  
  319. VAR
  320.    BS_Menu   : Menu_Type;
  321.    I         : INTEGER;
  322.    J         : INTEGER;
  323.  
  324. BEGIN (* Get_BackSpace *)
  325.                                    (* Get BackSpace Key Use *)
  326.    WITH BS_Menu DO
  327.       BEGIN
  328.  
  329.          Menu_Size    := 2;
  330.          Menu_Row     := 11;
  331.          Menu_Column  := 30;
  332.          Menu_Tcolor  := Menu_Text_Color;
  333.          Menu_Bcolor  := BackGround_Color;
  334.          Menu_Fcolor  := Menu_Frame_Color;
  335.          Menu_Width   := 0;
  336.          Menu_Height  := 0;
  337.  
  338.          IF BS_Char = CHR( BS ) THEN
  339.             Menu_Default := 1
  340.          ELSE
  341.             Menu_Default := 2;
  342.  
  343.       END (* WITH BS_Menu *);
  344.  
  345.    FOR I := 1 TO 2 DO
  346.       WITH BS_Menu.Menu_Entries[I] DO
  347.       BEGIN
  348.          Menu_Item_Row    := I;
  349.          Menu_Item_Column := 2;
  350.          CASE I OF
  351.             1:  Menu_Item_Text := 'Backspace (ASCII 08)';
  352.             2:  Menu_Item_Text := 'Delete    (ASCII 127)';
  353.          END (* CASE *);
  354.       END;
  355.  
  356.    BS_Menu.Menu_Title := 'Backspace key sends: ';
  357.  
  358.    Menu_Display_Choices( BS_Menu );
  359.  
  360.    CASE Menu_Get_Choice( BS_Menu, Erase_Menu ) OF
  361.  
  362.       1:  BEGIN
  363.              BS_Char      := CHR( BS  );
  364.              Ctrl_BS_Char := CHR( DEL );
  365.           END;
  366.  
  367.       2:  BEGIN
  368.              BS_Char      := CHR( DEL );
  369.              Ctrl_BS_Char := CHR( BS  );
  370.           END;
  371.  
  372.    END (* CASE *);
  373.  
  374. END   (* Get_BackSpace *);
  375.  
  376. (*----------------------------------------------------------------------*)
  377. (*                Get_LineFeeds --- Get CR/LF definition                *)
  378. (*----------------------------------------------------------------------*)
  379.  
  380. OVERLAY PROCEDURE Get_LineFeeds;
  381.  
  382. VAR
  383.    LF_Menu   : Menu_Type;
  384.    I         : INTEGER;
  385.    J         : INTEGER;
  386.  
  387. BEGIN (* Get_LineFeeds *)
  388.                                    (* Get CR/LF Key Use *)
  389.    WITH LF_Menu DO
  390.       BEGIN
  391.  
  392.          Menu_Size    := 2;
  393.          Menu_Row     := 11;
  394.          Menu_Column  := 30;
  395.          Menu_Tcolor  := Menu_Text_Color;
  396.          Menu_Bcolor  := BackGround_Color;
  397.          Menu_Fcolor  := Menu_Frame_Color;
  398.          Menu_Width   := 0;
  399.          Menu_Height  := 0;
  400.  
  401.          IF Add_LF THEN
  402.             Menu_Default := 2
  403.          ELSE
  404.             Menu_Default := 1;
  405.  
  406.       END;
  407.  
  408.    FOR I := 1 To 2 DO
  409.       WITH LF_Menu.Menu_Entries[I] DO
  410.       BEGIN
  411.          Menu_Item_Row    := I;
  412.          Menu_Item_Column := 2;
  413.          CASE I OF
  414.             1:  Menu_Item_Text := 'a) CR only';
  415.             2:  Menu_Item_Text := 'b) CR + LF';
  416.          END (* CASE *);
  417.       END;
  418.  
  419.    LF_Menu.Menu_Title := 'Incoming carriage return acts like: ';
  420.  
  421.    Menu_Display_Choices( LF_Menu );
  422.  
  423.    Add_LF := ( Menu_Get_Choice( LF_Menu, Erase_Menu ) = 2 );
  424.  
  425. END   (* Get_LineFeeds *);
  426.  
  427. (*----------------------------------------------------------------------*)
  428. (*        Get_Terminal_Type --- Get Type of Terminal to Emulate         *)
  429. (*----------------------------------------------------------------------*)
  430.  
  431. OVERLAY PROCEDURE Get_Terminal_Type;
  432.  
  433. CONST
  434.    Term_Data:  ARRAY[ 1 .. 6 ] OF Terminal_Type
  435.                = ( Dumb , VT52 , Ansi, VT100 , Gossip , HostMode );
  436.  
  437. VAR
  438.    Emul_Menu   : Menu_Type;
  439.    I           : INTEGER;
  440.    J           : INTEGER;
  441.  
  442. BEGIN (* Get_Terminal_Type *)
  443.                                    (* Get terminal type to emulate *)
  444.    Emul_Menu.Menu_Size    := 6;
  445.  
  446.    CASE Terminal_To_Emulate OF
  447.       Dumb:     Emul_Menu.Menu_Default := 1;
  448.       VT52:     Emul_Menu.Menu_Default := 2;
  449.       Ansi:     Emul_Menu.Menu_Default := 3;
  450.       VT100:    Emul_Menu.Menu_Default := 4;
  451.       Gossip:   Emul_Menu.Menu_Default := 5;
  452.       HostMode: Emul_Menu.Menu_Default := 6;
  453.    END (* CASE *);
  454.  
  455.    Emul_Menu.Menu_Row     := 11;
  456.    Emul_Menu.Menu_Column  := 30;
  457.    Emul_Menu.Menu_Tcolor  := Menu_Text_Color;
  458.    Emul_Menu.Menu_Bcolor  := BackGround_Color;
  459.    Emul_Menu.Menu_Fcolor  := Menu_Frame_Color;
  460.    Emul_Menu.Menu_Width   := 0;
  461.    Emul_Menu.Menu_Height  := 0;
  462.  
  463.    FOR I := 1 TO 6 DO
  464.       WITH Emul_Menu.Menu_Entries[I] DO
  465.       BEGIN
  466.          Menu_Item_Row    := I;
  467.          Menu_Item_Column := 2;
  468.          CASE I OF
  469.             1:  Menu_Item_Text := 'a) Dumb';
  470.             2:  Menu_Item_Text := 'b) VT52';
  471.             3:  Menu_Item_Text := 'c) ANSI';
  472.             4:  Menu_Item_Text := 'd) VT100';
  473.             5:  Menu_Item_Text := 'e) Gossip mode';
  474.             6:  Menu_Item_Text := 'f) Host Mode';
  475.          END (* CASE *);
  476.       END;
  477.  
  478.    Emul_Menu.Menu_Title := 'Terminal to emulate: ';
  479.  
  480.    Menu_Display_Choices( Emul_Menu );
  481.    Terminal_To_Emulate := Term_Data[ Menu_Get_Choice( Emul_Menu , Erase_Menu ) ];
  482.  
  483. END   (* Get_Terminal_Type *);
  484.  
  485. (*----------------------------------------------------------------------*)
  486. (*            Get_Modem_Setup --- Get setup values for modem            *)
  487. (*----------------------------------------------------------------------*)
  488.  
  489. OVERLAY PROCEDURE Get_Modem_Setup;
  490.  
  491. VAR
  492.    Modem_Menu  : Menu_Type;
  493.    I           : INTEGER;
  494.    J           : INTEGER;
  495.    Modem_Item  : INTEGER;
  496.    Done        : BOOLEAN;
  497.    Local_Save  : Saved_Screen_Ptr;
  498.    Local_Save2 : Saved_Screen_Ptr;
  499.    Param_Str   : AnyStr;
  500.    Param_Ival  : INTEGER;
  501.    Param_Rval  : REAL;
  502.    P_Str       : AnyStr;
  503.  
  504. BEGIN (* Get_Modem_Setup *)
  505.                                    (* Save screen *)
  506.    Save_Screen( Local_Save2 );
  507.                                    (* Get modem setup *)
  508.    Modem_Menu.Menu_Size    := 16;
  509.    Modem_Menu.Menu_Row     := 5;
  510.    Modem_Menu.Menu_Column  := 30;
  511.    Modem_Menu.Menu_Tcolor  := Menu_Text_Color;
  512.    Modem_Menu.Menu_Bcolor  := BackGround_Color;
  513.    Modem_Menu.Menu_Fcolor  := Menu_Frame_Color;
  514.    Modem_Menu.Menu_Width   := 0;
  515.    Modem_Menu.Menu_Height  := 0;
  516.    Modem_Menu.Menu_Default := 16;
  517.  
  518.    FOR I := 1 TO 16 DO
  519.       WITH Modem_Menu.Menu_Entries[I] DO
  520.       BEGIN
  521.          Menu_Item_Row    := I;
  522.          Menu_Item_Column := 2;
  523.          CASE I OF
  524.             1: Menu_Item_Text := 'a) Initialization String';
  525.             2: Menu_Item_Text := 'b) Dialing command prefix';
  526.             3: Menu_Item_Text := 'c) Connect message';
  527.             4: Menu_Item_Text := 'd) No Carrier message';
  528.             5: Menu_Item_Text := 'e) Busy message';
  529.             6: Menu_Item_Text := 'f) Escape string';
  530.             7: Menu_Item_Text := 'g) Escape Delay (ms)';
  531.             8: Menu_Item_Text := 'h) Hang Up string';
  532.             9: Menu_Item_Text := 'i) Dialing Timeout (secs)';
  533.            10: Menu_Item_Text := 'j) Redial Time (secs)';
  534.            11: Menu_Item_Text := 'k) Answer phone string';
  535.            12: Menu_Item_Text := 'l) Host mode setup';
  536.            13: Menu_Item_Text := 'm) Intercharacter delay (ms)';
  537.            14: Menu_Item_Text := 'n) Carrier line high';
  538.            15: Menu_Item_Text := 'o) Host mode auto speed detect';
  539.            16: Menu_Item_Text := 'q) Quit modem setup';
  540.          END (* CASE *);
  541.       END;
  542.  
  543.    Modem_Menu.Menu_Title := 'Choose modem item to set: ';
  544.  
  545.    Done       := FALSE;
  546.    Modem_Item := 0;
  547.  
  548.                                    (* If first time, display *)
  549.                                    (* modem header.          *)
  550.    IF First_Time THEN
  551.       BEGIN
  552.          Draw_Menu_Frame( 10, 10, 40, 13, Menu_Frame_Color,
  553.                           Menu_Text_Color, '' );
  554.          GoToXY( 1 , 1 );
  555.          ClrEol;
  556.          WRITE('Modem Setup');
  557.       END;
  558.  
  559.    REPEAT
  560.                                    (* If first time initialization, *)
  561.                                    (* proceed through each modem    *)
  562.                                    (* item in turn.                 *)
  563.       IF First_Time THEN
  564.          BEGIN
  565.             Modem_Item := Modem_Item + 1;
  566.          END
  567.       ELSE
  568.          BEGIN
  569.             Menu_Display_Choices( Modem_Menu );
  570.             Modem_Item := Menu_Get_Choice( Modem_Menu , Dont_Erase_Menu );
  571.          END;
  572.  
  573.       IF Modem_Item <> 16 THEN
  574.          BEGIN
  575.  
  576.             Save_Screen( Local_Save );
  577.  
  578.             WITH Modem_Menu.Menu_Entries[Modem_Item] DO
  579.                P_Str := 'Enter Modem ' + COPY( Menu_Item_Text, 4,
  580.                                                LENGTH( Menu_Item_Text ) - 3 );
  581.  
  582.             Draw_Menu_Frame( 10, 20, 65, 24, Menu_Frame_Color,
  583.                              Menu_Text_Color, P_Str );
  584.  
  585.             Window( 11, 21, 64, 23 );
  586.  
  587.             GoToXY( 1 , 1 );
  588.             WRITE('Current value: ');
  589.  
  590.             CASE Modem_Item OF
  591.                1 :  WRITE( Modem_Init );
  592.                2 :  WRITE( Modem_Dial );
  593.                3 :  WRITE( Modem_Connect );
  594.                4 :  WRITE( Modem_No_Carrier );
  595.                5 :  WRITE( Modem_Busy );
  596.                6 :  WRITE( Modem_Escape );
  597.                7 :  WRITE( Modem_Escape_Time );
  598.                8 :  WRITE( Modem_Hang_Up );
  599.                9 :  WRITE( Modem_Time_Out:4:0 );
  600.               10 :  WRITE( Modem_Redial_Delay:4:0 );
  601.               11 :  WRITE( Modem_Answer );
  602.               12 :  WRITE( Modem_Host_Set );
  603.               13 :  WRITE( Modem_Command_Delay );
  604.               14 :  IF Modem_Carrier_High THEN
  605.                        WRITE('Always on')
  606.                     ELSE
  607.                        WRITE('Not always on');
  608.               15 :  IF Host_Auto_Baud THEN
  609.                        WRITE('Detect speed from modem')
  610.                     ELSE
  611.                        WRITE('Detect speed from user input');
  612.               ELSE ;
  613.             END (* CASE *);
  614.  
  615.             GoToXY( 1 , 2 );
  616.             ClrEol;
  617.             WRITE('--> ');
  618.  
  619.             IF Modem_Item = 14 THEN
  620.                BEGIN
  621.                   Modem_Carrier_High :=
  622.                      YesNo('Is Carrier Detect Signal Always On (Y/N) ');
  623.                END
  624.             ELSE IF Modem_Item = 15 THEN
  625.                BEGIN
  626.                   Host_Auto_Baud :=
  627.                      YesNo('Try automatic speed detect in host mode (Y/N) ');
  628.                END
  629.             ELSE
  630.                BEGIN
  631.  
  632.                   READLN( Param_Str );
  633.  
  634.                   IF ( LENGTH( Param_Str ) > 0 ) THEN
  635.                      BEGIN
  636.  
  637.                         Param_Ival := 0;
  638.                         Param_Str  := Read_Ctrls( TRIM( Param_Str ) );
  639.  
  640.                         FOR I := 1 TO LENGTH( Param_Str ) DO
  641.                            IF Param_Str[I] IN ['0'..'9'] THEN
  642.                               Param_Ival := Param_Ival * 10 +
  643.                                             ORD( Param_Str[I] ) - ORD( '0' );
  644.  
  645.                         Param_Rval := Param_Ival;
  646.  
  647.                         CASE Modem_Item OF
  648.                            1 :  Modem_Init          := Param_Str;
  649.                            2 :  Modem_Dial          := Param_Str;
  650.                            3 :  Modem_Connect       := Param_Str;
  651.                            4 :  Modem_No_Carrier    := Param_Str;
  652.                            5 :  Modem_Busy          := Param_Str;
  653.                            6 :  Modem_Escape        := Param_Str;
  654.                            7 :  Modem_Escape_Time   := Param_Ival;
  655.                            8 :  Modem_Hang_Up       := Param_Str;
  656.                            9 :  Modem_Time_Out      := Param_Rval;
  657.                           10 :  Modem_Redial_Delay  := Param_Rval;
  658.                           11 :  Modem_Answer        := Param_Str;
  659.                           12 :  Modem_Host_Set      := Param_Str;
  660.                           13 :  Modem_Command_Delay := Param_Ival;
  661.                           ELSE ;
  662.                        END (* CASE *);
  663.  
  664.                      END  (* LENGTH( Param_Str ) > 0 *);
  665.  
  666.                END;
  667.  
  668.             Restore_Screen( Local_Save );
  669.  
  670.          END (* Modem_Item <> 16 *)
  671.       ELSE
  672.          Done := TRUE;
  673.  
  674.    UNTIL Done;
  675.  
  676.    Restore_Screen( Local_Save2 );
  677.  
  678. END   (* Get_Modem_Setup *);
  679.  
  680. (*----------------------------------------------------------------------*)
  681. (*   Get_Default_Transfer_Protocol --- get protocol for file transfers  *)
  682. (*----------------------------------------------------------------------*)
  683.  
  684. OVERLAY PROCEDURE Get_Default_Transfer_Protocol;
  685.  
  686. VAR
  687.    Transfer_Menu : Menu_Type;
  688.    I             : INTEGER;
  689.  
  690. BEGIN (* Get_Default_Transfer_Protocol *)
  691.  
  692.    Transfer_Menu.Menu_Size    := 10;
  693.    Transfer_Menu.Menu_Row     := 10;
  694.    Transfer_Menu.Menu_Column  := 30;
  695.    Transfer_Menu.Menu_Tcolor  := Menu_Text_Color;
  696.    Transfer_Menu.Menu_Bcolor  := BackGround_Color;
  697.    Transfer_Menu.Menu_Fcolor  := Menu_Frame_Color;
  698.    Transfer_Menu.Menu_Width   := 40;
  699.    Transfer_Menu.Menu_Height  := 0;
  700.  
  701.    CASE Default_Transfer_Type OF
  702.       Ascii:        Transfer_Menu.Menu_Default := 1;
  703.       Xmodem_Chk:   Transfer_Menu.Menu_Default := 2;
  704.       Xmodem_Crc:   Transfer_Menu.Menu_Default := 3;
  705.       Kermit:       Transfer_Menu.Menu_Default := 4;
  706.       Telink:       Transfer_Menu.Menu_Default := 5;
  707.       Modem7_Chk:   Transfer_Menu.Menu_Default := 6;
  708.       Modem7_CRC:   Transfer_Menu.Menu_Default := 7;
  709.       Ymodem:       Transfer_Menu.Menu_Default := 8;
  710.       Ymodem_Batch: Transfer_Menu.Menu_Default := 9;
  711.       None:         Transfer_Menu.Menu_Default := 10;
  712.    END (* CASE *);
  713.  
  714.    FOR I := 1 TO 10 DO
  715.       WITH Transfer_Menu.Menu_Entries[I] DO
  716.       BEGIN
  717.  
  718.          Menu_Item_Row    := I;
  719.          Menu_Item_Column := 2;
  720.  
  721.          CASE I OF
  722.  
  723.             1:  Menu_Item_Text := 'a) Ascii';
  724.             2:  Menu_Item_Text := 'b) Xmodem (Checksum)';
  725.             3:  Menu_Item_Text := 'c) Xmodem (CRC)';
  726.             4:  Menu_Item_Text := 'd) Kermit';
  727.             5:  Menu_Item_Text := 'e) Telink';
  728.             6:  Menu_Item_Text := 'f) Modem7 (Checksum)';
  729.             7:  Menu_Item_Text := 'g) Modem7 (CRC)';
  730.             8:  Menu_Item_Text := 'h) Ymodem';
  731.             9:  Menu_Item_Text := 'i) Ymodem (Batch)';
  732.            10:  Menu_Item_Text := 'j) None';
  733.  
  734.          END (* CASE *);
  735.  
  736.       END;
  737.                                    (* Get transfer protocol *)
  738.  
  739.    Transfer_Menu.Menu_Title := 'Default file transfer protocol';
  740.  
  741.    Menu_Display_Choices( Transfer_Menu );
  742.    Default_Transfer_Type := Transfers[ Menu_Get_Choice( Transfer_Menu ,
  743.                                                         Erase_Menu ) ];
  744.  
  745. END   (* Get_Default_Transfer_Protocol *);
  746.  
  747. (*----------------------------------------------------------------------*)
  748. (*        Get_Screen_Dump_Name --- get file name for screen dumps       *)
  749. (*----------------------------------------------------------------------*)
  750.  
  751. OVERLAY PROCEDURE Get_Screen_Dump_Name;
  752.  
  753. BEGIN (* Get_Screen_Dump_Name *)
  754.  
  755.    Save_Screen( Saved_Screen );
  756.    Draw_Menu_Frame( 10, 10, 78, 13, Menu_Frame_Color,
  757.                     Menu_Text_Color, 'Set screen dump file name' );
  758.  
  759.    WRITE('File name to receive screen dumps? ');
  760.    READLN( Screen_Dump_Name );
  761.  
  762.    Restore_Screen( Saved_Screen );
  763.    Reset_Global_Colors;
  764.  
  765. END   (* Get_Screen_Dump_Name *);
  766.  
  767. (*----------------------------------------------------------------------*)
  768. (*     Get_Video_Mode_And_Colors --- Get video mode and colors          *)
  769. (*----------------------------------------------------------------------*)
  770.  
  771. OVERLAY PROCEDURE Get_Video_Mode_And_Colors;
  772.  
  773. VAR
  774.    Video_Menu   : Menu_Type;
  775.    Color_Menu   : Menu_Type;
  776.    I            : INTEGER;
  777.    J            : INTEGER;
  778.  
  779. BEGIN (* Get_Video_Mode_And_Colors *)
  780.  
  781.                                    (* Get Video Mode *)
  782.    WITH Video_Menu DO
  783.       BEGIN
  784.  
  785.          Menu_Size    := 2;
  786.          Menu_Row     := 11;
  787.          Menu_Column  := 30;
  788.          Menu_Tcolor  := Menu_Text_Color;
  789.          Menu_Bcolor  := BackGround_Color;
  790.          Menu_Fcolor  := Menu_Frame_Color;
  791.          Menu_Width   := 0;
  792.          Menu_Height  := 0;
  793.  
  794.          IF Text_Mode = BW80 THEN
  795.             Menu_Default := 1
  796.          ELSE
  797.             Menu_Default := 2;
  798.  
  799.       END (* WITH Video_Menu *);
  800.  
  801.    FOR I := 1 TO 2 DO
  802.       WITH Video_Menu.Menu_Entries[I] DO
  803.       BEGIN
  804.          Menu_Item_Row    := I;
  805.          Menu_Item_Column := 2;
  806.          CASE I OF
  807.             1:  Menu_Item_Text := 'Monochrome (BW80)';
  808.             2:  Menu_Item_Text := 'Color      (C80)';
  809.          END (* CASE *);
  810.       END;
  811.  
  812.    Video_Menu.Menu_Title := 'Choose Text Mode: ';
  813.  
  814.    Menu_Display_Choices( Video_Menu );
  815.  
  816.    CASE Menu_Get_Choice( Video_Menu, Erase_Menu ) OF
  817.  
  818.       1:  New_Text_Mode := BW80;
  819.       2:  New_Text_Mode := C80;
  820.  
  821.    END (* CASE *);
  822.                                    (* Monochrome -- all colors *)
  823.                                    (* become black and white   *)
  824.  
  825.    IF New_Text_Mode = BW80 THEN
  826.       BEGIN
  827.  
  828.          New_ForeGround_Color   := White;
  829.          New_BackGround_Color   := Black;
  830.          New_Menu_Text_Color    := White;
  831.          New_Menu_Frame_Color   := White;
  832.  
  833.          VT100_ForeGround_Color := LightGray;
  834.          VT100_BackGround_Color := Black;
  835.          VT100_Underline_Color  := Blue;
  836.          VT100_Bold_Color       := White;
  837.  
  838.       END
  839.    ELSE                            (* Color -- give them a choice *)
  840.       BEGIN  (* Choose colors *)
  841.                                    (* Set up color menu *)
  842.          WITH Color_Menu DO
  843.             BEGIN
  844.  
  845.                Menu_Size    := 16;
  846.                Menu_Row     := 6;
  847.                Menu_Column  := 30;
  848.                Menu_Tcolor  := Menu_Text_Color;
  849.                Menu_Bcolor  := BackGround_Color;
  850.                Menu_Fcolor  := Menu_Frame_Color;
  851.                Menu_Width   := 0;
  852.                Menu_Height  := 0;
  853.  
  854.             END (* WITH Color_Menu *);
  855.  
  856.          FOR I := 1 TO 16 DO
  857.             WITH Color_Menu.Menu_Entries[I] DO
  858.                BEGIN
  859.  
  860.                   Menu_Item_Row    := I;
  861.                   Menu_Item_Column := 2;
  862.  
  863.                   CASE I OF
  864.                      1:  Menu_Item_Text := 'a) Black';
  865.                      2:  Menu_Item_Text := 'b) Blue';
  866.                      3:  Menu_Item_Text := 'c) Green';
  867.                      4:  Menu_Item_Text := 'd) Cyan';
  868.                      5:  Menu_Item_Text := 'e) Red';
  869.                      6:  Menu_Item_Text := 'f) Magenta';
  870.                      7:  Menu_Item_Text := 'g) Brown';
  871.                      8:  Menu_Item_Text := 'h) LightGray';
  872.                      9:  Menu_Item_Text := 'i) DarkGray';
  873.                      10: Menu_Item_Text := 'j) LightBlue';
  874.                      11: Menu_Item_Text := 'k) LightGreen';
  875.                      12: Menu_Item_Text := 'l) LightCyan';
  876.                      13: Menu_Item_Text := 'm) LightRed';
  877.                      14: Menu_Item_Text := 'n) LightMagenta';
  878.                      15: Menu_Item_Text := 'o) Yellow';
  879.                      16: Menu_Item_Text := 'p) White';
  880.                   END (* CASE *);
  881.  
  882.                END;
  883.                                    (* Get foreground *)
  884.  
  885.          Color_Menu.Menu_Title   := 'Foreground Color: ';
  886.          Color_Menu.Menu_Default := ForeGround_Color + 1;
  887.  
  888.          Menu_Display_Choices( Color_Menu );
  889.  
  890.          New_ForeGround_Color := Menu_Get_Choice( Color_Menu , Erase_Menu ) - 1;
  891.  
  892.                                    (* Get background *)
  893.  
  894.          Color_Menu.Menu_Title   := 'Background Color: ';
  895.          Color_Menu.Menu_Default := BackGround_Color + 1;
  896.  
  897.          Menu_Display_Choices( Color_Menu );
  898.  
  899.          New_BackGround_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  900.  
  901.                                    (* Menu frame color *)
  902.  
  903.          Color_Menu.Menu_Title   := 'Menu Frame Color: ';
  904.          Color_Menu.Menu_Default := Menu_Frame_Color + 1;
  905.  
  906.          Menu_Display_Choices( Color_Menu );
  907.  
  908.          New_Menu_Frame_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  909.  
  910.                                    (* Menu text color *)
  911.  
  912.          Color_Menu.Menu_Title   := 'Menu Text Color: ';
  913.          Color_Menu.Menu_Default := Menu_Text_Color + 1;
  914.  
  915.          Menu_Display_Choices( Color_Menu );
  916.  
  917.          New_Menu_Text_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  918.  
  919.                                    (* VT100 foreground color *)
  920.  
  921.          Color_Menu.Menu_Title   := 'VT100 Foreground Color: ';
  922.          Color_Menu.Menu_Default := VT100_ForeGround_Color + 1;
  923.  
  924.          Menu_Display_Choices( Color_Menu );
  925.  
  926.          VT100_ForeGround_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  927.  
  928.                                    (* VT100 background color *)
  929.  
  930.          Color_Menu.Menu_Title   := 'VT100 Background Color: ';
  931.          Color_Menu.Menu_Default := VT100_BackGround_Color + 1;
  932.  
  933.          Menu_Display_Choices( Color_Menu );
  934.  
  935.          VT100_BackGround_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  936.  
  937.                                    (* VT100 underline color *)
  938.  
  939.          Color_Menu.Menu_Title   := 'VT100 Underline Color: ';
  940.          Color_Menu.Menu_Default := VT100_Underline_Color + 1;
  941.  
  942.          Menu_Display_Choices( Color_Menu );
  943.  
  944.          VT100_Underline_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  945.  
  946.                                    (* VT100 bolding color *)
  947.  
  948.          Color_Menu.Menu_Title   := 'VT100 Bold Color: ';
  949.          Color_Menu.Menu_Default := VT100_Bold_Color + 1;
  950.  
  951.          Menu_Display_Choices( Color_Menu );
  952.  
  953.          VT100_Bold_Color := Menu_Get_Choice( Color_Menu, Erase_Menu ) - 1;
  954.  
  955.       END   (* Choose colors *);
  956.  
  957. END   (* Get_Video_Mode_And_Colors *);
  958.  
  959. (*----------------------------------------------------------------------*)
  960. (*           Get_Miscellaneous --- Get miscellaneous parameters         *)
  961. (*----------------------------------------------------------------------*)
  962.  
  963. OVERLAY PROCEDURE Get_Miscellaneous;
  964.  
  965. VAR
  966.    Local_Save   : Saved_Screen_Ptr;
  967.    Local_Save_2 : Saved_Screen_Ptr;
  968.    Misc_Menu    : Menu_Type;
  969.    Done         : BOOLEAN;
  970.    L            : INTEGER;
  971.    Choice       : INTEGER;
  972.  
  973. BEGIN (* Get_Miscellaneous *)
  974.                                    (* Save current screen *)
  975.    Save_Screen( Local_Save_2 );
  976.                                    (* Set up menu *)
  977.    WITH Misc_Menu DO
  978.       BEGIN
  979.  
  980.          Menu_Size    := 6;
  981.          Menu_Row     := 11;
  982.          Menu_Column  := 30;
  983.          Menu_Tcolor  := Menu_Text_Color;
  984.          Menu_Bcolor  := BackGround_Color;
  985.          Menu_Fcolor  := Menu_Frame_Color;
  986.          Menu_Width   := 0;
  987.          Menu_Height  := 0;
  988.          Menu_Default := 6;
  989.  
  990.       END (* WITH Misc_Menu *);
  991.  
  992.    FOR I := 1 TO 6 DO
  993.       WITH Misc_Menu.Menu_Entries[I] DO
  994.       BEGIN
  995.          Menu_Item_Row    := I;
  996.          Menu_Item_Column := 2;
  997.          CASE I OF
  998.             1:  Menu_Item_Text := 'a) EXEC PC BBS Commands';
  999.             2:  Menu_Item_Text := 'b) CompuServe B Protocol';
  1000.             3:  Menu_Item_Text := 'c) Exploding menus';
  1001.             4:  Menu_Item_Text := 'd) Review scrolled lines';
  1002.             5:  Menu_Item_Text := 'e) Xmodem download buffer size';
  1003.             6:  Menu_Item_Text := 'q) Quit';
  1004.          END (* CASE *);
  1005.       END;
  1006.  
  1007.    Misc_Menu.Menu_Title := 'Miscellaneous Parameters: ';
  1008.  
  1009.    Done := FALSE;
  1010.                                    (* Loop over menu choices *)
  1011.    REPEAT
  1012.  
  1013.       Menu_Display_Choices( Misc_Menu );
  1014.  
  1015.       Choice := Menu_Get_Choice( Misc_Menu, Dont_Erase_Menu );
  1016.  
  1017.       IF Choice <> 6 THEN
  1018.          BEGIN
  1019.  
  1020.             Save_Screen( Local_Save );
  1021.  
  1022.             Draw_Menu_Frame( 10, 20, 65, 24, Menu_Frame_Color,
  1023.                              Menu_Text_Color, '' );
  1024.  
  1025.             Window( 11, 21, 64, 23 );
  1026.  
  1027.             GoToXY( 1 , 1 );
  1028.  
  1029.             CASE Choice OF
  1030.  
  1031.                1:  Mahoney_On      := YesNo('Execute EXEC PC BBS commands in VT52 mode? ');
  1032.  
  1033.                2:  CompuServe_B_On := YesNo('Execute CompuServe B Protocol? ');
  1034.  
  1035.                3:  BEGIN
  1036.                       Exploding_Menus := YesNo('Use exploding menus? ');
  1037.                       Menu_Set_Explode( Exploding_Menus );
  1038.                    END;
  1039.  
  1040.                4:  BEGIN
  1041.  
  1042.                       WRITE('Enter number of lines to use for review buffer: ');
  1043.  
  1044.                       L := Max_Review_Length;
  1045.  
  1046.                       READLN( Max_Review_Length );
  1047.  
  1048.                       Max_Review_Length := MIN( MAX( Max_Review_Length , 0 ) ,
  1049.                                                 800 );
  1050.  
  1051.                       IF ( L > 0 ) AND ( Review_Buffer <> NIL ) THEN
  1052.                          BEGIN
  1053.                             FreeMem( Review_Buffer , 81 * L );
  1054.                             Review_Buffer := NIL;
  1055.                          END;
  1056.  
  1057.                       L := 81 * Max_Review_Length;
  1058.  
  1059.                       IF L > ( MaxBlockAvail - 32000.0 ) THEN
  1060.                          BEGIN
  1061.                             Max_Review_Length    := MAX( 0 ,
  1062.                                                          TRUNC( ( MaxBlockAvail - 32000.0 ) / 81.0 ) );
  1063.                             L                    := 81 * Max_Review_Length;
  1064.                          END;
  1065.  
  1066.                       Review_On := ( Max_Review_Length > 0 );
  1067.  
  1068.                       IF Review_On THEN
  1069.                          GetMem( Review_Buffer , L );
  1070.  
  1071.                       Review_Head      := 0;
  1072.                       Review_Tail      := 0;
  1073.                       Review_Line      := '';
  1074.  
  1075.                    END;
  1076.  
  1077.                5:  BEGIN
  1078.  
  1079.                       WRITE('Enter size in bytes for Xmodem download buffer: ');
  1080.  
  1081.                       READLN( Max_Write_Buffer );
  1082.  
  1083.                       Max_Write_Buffer :=
  1084.                          MAX( ( ( Max_Write_Buffer + 127 ) DIV 128 ) * 128,
  1085.                               128 );
  1086.  
  1087.                    END;
  1088.  
  1089.                6:  Done := TRUE;
  1090.  
  1091.                ELSE;
  1092.  
  1093.             END (* CASE *);
  1094.  
  1095.             Restore_Screen( Local_Save );
  1096.             Reset_Global_Colors;
  1097.  
  1098.          END
  1099.       ELSE
  1100.          Done := TRUE;
  1101.  
  1102.    UNTIL Done;
  1103.                                    (* Restore previous screen *)
  1104.    Restore_Screen( Local_Save_2 );
  1105.  
  1106. END   (* Get_Miscellaneous *);
  1107.  
  1108. (*----------------------------------------------------------------------*)
  1109. (*           Get_Kermit_Params --- Get Kermit protocol parameters       *)
  1110. (*----------------------------------------------------------------------*)
  1111.  
  1112. OVERLAY PROCEDURE Get_Kermit_Params;
  1113.  
  1114. VAR
  1115.    Kermit_Menu : Menu_Type;
  1116.    I           : INTEGER;
  1117.    J           : INTEGER;
  1118.    Kermit_Item : INTEGER;
  1119.    Done        : BOOLEAN;
  1120.    Local_Save  : Saved_Screen_Ptr;
  1121.    Local_Save2 : Saved_Screen_Ptr;
  1122.    Param_Str   : AnyStr;
  1123.    Param_Ival  : INTEGER;
  1124.    Param_Rval  : REAL;
  1125.    P_Str       : AnyStr;
  1126.  
  1127. (*----------------------------------------------------------------------*)
  1128.  
  1129. FUNCTION SIval( I: INTEGER ) : ShortStr;
  1130.  
  1131. VAR
  1132.    IWidth : INTEGER;
  1133.    ISave  : INTEGER;
  1134.    S      : ShortStr;
  1135.  
  1136. BEGIN (* SIval *)
  1137.  
  1138.    IWidth := 0;
  1139.    ISave  := I;
  1140.  
  1141.    WHILE( ISave > 0 ) DO
  1142.       BEGIN
  1143.          IWidth := IWidth + 1;
  1144.          ISave  := ISave DIV 10;
  1145.       END;
  1146.  
  1147.    STR( I : IWidth , S );
  1148.  
  1149.    SIVal := S;
  1150.  
  1151. END   (* SIval *);
  1152.  
  1153. (*----------------------------------------------------------------------*)
  1154.  
  1155. PROCEDURE Get_Kermit_Menu_Line( I: INTEGER );
  1156.  
  1157. BEGIN (* Get_Kermit_Menu_Line *)
  1158.  
  1159.    WITH Kermit_Menu.Menu_Entries[I] DO
  1160.       BEGIN
  1161.  
  1162.          CASE I OF
  1163.  
  1164.             1: Menu_Item_Text :=
  1165.                'a) Checksum type (now ' + Kermit_Chk_Type + ')';
  1166.  
  1167.             2: BEGIN
  1168.                   Menu_Item_Text := 'b) Debug mode (now ';
  1169.                   IF Kermit_Debug THEN
  1170.                      Menu_Item_Text := Menu_Item_Text + 'ON)'
  1171.                   ELSE
  1172.                      Menu_Item_Text := Menu_Item_Text + 'OFF)';
  1173.                END;
  1174.  
  1175.             3: Menu_Item_Text := 'c) End of line (now Ascii ' +
  1176.                                  SIval( ORD( Kermit_EOL ) ) + ')';
  1177.  
  1178.             4: Menu_Item_Text := 'd) Packet header (now Ascii ' +
  1179.                                  SIval( ORD( Kermit_Header_Char ) ) + ')';
  1180.  
  1181.             5: Menu_Item_Text := 'e) Number of pad characters (now ' +
  1182.                                  SIval( Kermit_NPad ) + ')';
  1183.  
  1184.             6: Menu_Item_Text := 'f) Pad character (now Ascii ' +
  1185.                                  SIval( ORD( Kermit_Pad_Char ) ) + ')';
  1186.  
  1187.             7: Menu_Item_Text := 'g) Control quote (now Ascii ' +
  1188.                                  SIval( ORD( Kermit_Quote_Char ) ) + ')';
  1189.  
  1190.             8: Menu_Item_Text := 'h) 8 bit quote (now Ascii ' +
  1191.                                  SIval( ORD( Kermit_Quote_8_Char ) ) + ')';
  1192.  
  1193.             9: Menu_Item_Text := 'i) Repeat data (now Ascii ' +
  1194.                                  SIval( ORD( Kermit_Repeat_Char ) ) + ')';
  1195.  
  1196.            10: Menu_Item_Text := 'j) Packet size (now ' +
  1197.                                  SIval( Kermit_Packet_Size ) + ')';
  1198.  
  1199.            11: Menu_Item_Text := 'k) Timeout in seconds (now ' +
  1200.                                  SIval( Kermit_TimeOut ) + ')';
  1201.  
  1202.            12: Menu_Item_Text := 'k) Send delay in seconds (now ' +
  1203.                                  SIval( Kermit_Delay_Time ) + ')';
  1204.  
  1205.            13: Menu_Item_Text := 'q) Quit Kermit definitions';
  1206.  
  1207.          END (* CASE *);
  1208.  
  1209.       END;
  1210.  
  1211. END   (* Get_Kermit_Menu_Line *);
  1212.  
  1213. (*----------------------------------------------------------------------*)
  1214.  
  1215. BEGIN (* Get_Kermit_Params *)
  1216.                                    (* Save screen *)
  1217.    Save_Screen( Local_Save2 );
  1218.                                    (* Get Kermit setup *)
  1219.    Kermit_Menu.Menu_Size    := 13;
  1220.    Kermit_Menu.Menu_Row     := 5;
  1221.    Kermit_Menu.Menu_Column  := 15;
  1222.    Kermit_Menu.Menu_Tcolor  := Menu_Text_Color;
  1223.    Kermit_Menu.Menu_Bcolor  := BackGround_Color;
  1224.    Kermit_Menu.Menu_Fcolor  := Menu_Frame_Color;
  1225.    Kermit_Menu.Menu_Width   := 50;
  1226.    Kermit_Menu.Menu_Height  := 0;
  1227.    Kermit_Menu.Menu_Default := 13;
  1228.  
  1229.    FOR I := 1 TO 13 DO
  1230.       WITH Kermit_Menu.Menu_Entries[I] DO
  1231.          BEGIN
  1232.  
  1233.             Menu_Item_Row    := I;
  1234.             Menu_Item_Column := 2;
  1235.  
  1236.             Get_Kermit_Menu_Line( I );
  1237.  
  1238.          END;
  1239.  
  1240.    Kermit_Menu.Menu_Title := 'Choose Kermit item to set: ';
  1241.  
  1242.    Done        := FALSE;
  1243.    Kermit_Item := 0;
  1244.  
  1245.                                    (* If first time, display *)
  1246.                                    (* modem header.          *)
  1247.    IF First_Time THEN
  1248.       BEGIN
  1249.          Draw_Menu_Frame( 10, 10, 40, 13, Menu_Frame_Color,
  1250.                           Menu_Text_Color, '' );
  1251.          GoToXY( 1 , 1 );
  1252.          ClrEol;
  1253.          WRITE('Kermit parameters');
  1254.       END;
  1255.  
  1256.    REPEAT
  1257.                                    (* If first time initialization, *)
  1258.                                    (* proceed through each modem    *)
  1259.                                    (* item in turn.                 *)
  1260.       IF First_Time THEN
  1261.          BEGIN
  1262.             Kermit_Item := Kermit_Item + 1;
  1263.          END
  1264.       ELSE
  1265.          BEGIN
  1266.             Menu_Display_Choices( Kermit_Menu );
  1267.             Kermit_Item := Menu_Get_Choice( Kermit_Menu , Dont_Erase_Menu );
  1268.          END;
  1269.  
  1270.       IF Kermit_Item <> 13 THEN
  1271.          BEGIN
  1272.  
  1273.             Save_Screen( Local_Save );
  1274.  
  1275.             WITH Kermit_Menu.Menu_Entries[Kermit_Item] DO
  1276.                P_Str := 'Enter Kermit ' + COPY( Menu_Item_Text, 4,
  1277.                                                LENGTH( Menu_Item_Text ) - 3 );
  1278.  
  1279.             Draw_Menu_Frame( 10, 20, 65, 24, Menu_Frame_Color,
  1280.                              Menu_Text_Color, P_Str );
  1281.  
  1282.             Window( 11, 21, 64, 23 );
  1283.  
  1284.             GoToXY( 1 , 1 );
  1285.             ClrEol;
  1286.             WRITE('--> ');
  1287.  
  1288.             READLN( Param_Str );
  1289.  
  1290.             Restore_Screen( Local_Save );
  1291.  
  1292.             IF ( LENGTH( Param_Str ) > 0 ) THEN
  1293.                BEGIN
  1294.  
  1295.                   Param_Ival := 0;
  1296.                   Param_Str  := Read_Ctrls( TRIM( Param_Str ) );
  1297.  
  1298.                   IF ( LENGTH( Param_Str ) = 0 ) THEN
  1299.                      Param_Str := ' ';
  1300.  
  1301.                   FOR I := 1 TO LENGTH( Param_Str ) DO
  1302.                      IF Param_Str[I] IN ['0'..'9'] THEN
  1303.                         Param_Ival := Param_Ival * 10 + ORD( Param_Str[I] ) -
  1304.                                                         ORD( '0' );
  1305.                   Param_Rval := Param_Ival;
  1306.  
  1307.                   CASE Kermit_Item OF
  1308.                      1 :  Kermit_Chk_Type        := Param_Str[1];
  1309.                      2 :  Kermit_Debug           := ( UpperCase(Param_Str) = 'ON' );
  1310.                      3 :  Kermit_EOL             := Param_Str[1];
  1311.                      4 :  Kermit_Header_Char     := Param_Str[1];
  1312.                      5 :  Kermit_Npad            := MAX( Param_Ival , 0 );
  1313.                      6 :  Kermit_Pad_Char        := Param_Str[1];
  1314.                      7 :  Kermit_Quote_Char      := Param_Str[1];
  1315.                      8 :  Kermit_Quote_8_Char    := Param_Str[1];
  1316.                      9 :  Kermit_Repeat_Char     := Param_Str[1];
  1317.                     10 :  Kermit_Packet_Size     := MIN( MAX( Param_Ival , 20 ) , 94 );
  1318.                     11 :  Kermit_TimeOut         := Param_Ival;
  1319.                     12 :  Kermit_Delay_Time      := Param_Ival;
  1320.                     ELSE ;
  1321.  
  1322.                   END (* CASE *);
  1323.  
  1324.                   Get_Kermit_Menu_Line( Kermit_Item );
  1325.  
  1326.                END (* LENGTH( Param_Str ) > 0 *);
  1327.  
  1328.          END  (* Kermit_Item <> 13 *)
  1329.       ELSE
  1330.          Done := TRUE;
  1331.  
  1332.    UNTIL Done;
  1333.  
  1334.    Restore_Screen( Local_Save2 );
  1335.  
  1336. END   (* Get_Kermit_Params *);
  1337.  
  1338. (*----------------------------------------------------------------------*)
  1339.  
  1340. BEGIN (* Get_Default_Params *)
  1341.  
  1342.                                    (* If first time, get all params *)
  1343.    IF First_Time THEN
  1344.       BEGIN
  1345.                                    (* Get other stuff *)
  1346.          Get_Comm_Port;
  1347.          Get_Baud_Rate;
  1348.          Get_Parity;
  1349.          Get_Data_Bits;
  1350.          Get_Stop_Bits;
  1351.          Get_BackSpace;
  1352.          Get_LineFeeds;
  1353.          Get_Terminal_Type;
  1354.          Get_Modem_Setup;
  1355.          Get_Default_Transfer_Protocol;
  1356.          Get_Screen_Dump_Name;
  1357.          Get_Video_Mode_And_Colors;
  1358.  
  1359.       END                          (* Not first time -- prompt for *)
  1360.                                    (* params to be changed         *)
  1361.    ELSE
  1362.       BEGIN
  1363.  
  1364.          Settings_Menu.Menu_Size    := 17;
  1365.          Settings_Menu.Menu_Row     :=  5;
  1366.          Settings_Menu.Menu_Column  := 30;
  1367.          Settings_Menu.Menu_Tcolor  := Menu_Text_Color;
  1368.          Settings_Menu.Menu_Bcolor  := BackGround_Color;
  1369.          Settings_Menu.Menu_Fcolor  := Menu_Frame_Color;
  1370.          Settings_Menu.Menu_Width   := 0;
  1371.          Settings_Menu.Menu_Height  := 0;
  1372.          Settings_Menu.Menu_Default := 17;
  1373.  
  1374.          FOR I := 1 TO 17 DO
  1375.             WITH Settings_Menu.Menu_Entries[I] DO
  1376.                BEGIN
  1377.                   Menu_Item_Row    := I;
  1378.                   Menu_Item_Column := 2;
  1379.                   CASE I OF
  1380.                      1: Menu_Item_Text := 'a) Communications Port';
  1381.                      2: Menu_Item_Text := 'b) Speed (Baud Rate)';
  1382.                      3: Menu_Item_Text := 'c) Parity';
  1383.                      4: Menu_Item_Text := 'd) Data Bits';
  1384.                      5: Menu_Item_Text := 'e) Stop Bits';
  1385.                      6: Menu_Item_Text := 'f) Backspace';
  1386.                      7: Menu_Item_Text := 'g) Linefeed toggle';
  1387.                      8: Menu_Item_Text := 'h) Terminal Type';
  1388.                      9: Menu_Item_Text := 'i) Modem setup';
  1389.                     10: Menu_Item_Text := 'j) File transfer protocol';
  1390.                     11: Menu_Item_Text := 'k) Kermit parameters';
  1391.                     12: Menu_Item_Text := 'l) Screen dump file name';
  1392.                     13: Menu_Item_Text := 'm) Video mode and colors';
  1393.                     14: Menu_Item_Text := 'n) Miscellaneous';
  1394.                     15: Menu_Item_Text := 's) Execute Script file';
  1395.                     16: Menu_Item_Text := 'w) Write new config file';
  1396.                     17: Menu_Item_Text := 'q) Quit setup';
  1397.                   END (* CASE *);
  1398.                END;
  1399.  
  1400.          Settings_Menu.Menu_Title := 'Set parameters';
  1401.  
  1402.                                    (* Request setup parameters until *)
  1403.                                    (* stop setup selected            *)
  1404.          REPEAT
  1405.  
  1406.             Menu_Display_Choices( Settings_Menu );
  1407.             Settings_Choice := Menu_Get_Choice( Settings_Menu , Erase_Menu );
  1408.  
  1409.             CASE Settings_Choice OF
  1410.  
  1411.                 1:   Get_Comm_Port;
  1412.                 2:   Get_Baud_Rate;
  1413.                 3:   Get_Parity;
  1414.                 4:   Get_Data_Bits;
  1415.                 5:   Get_Stop_Bits;
  1416.                 6:   Get_BackSpace;
  1417.                 7:   Get_LineFeeds;
  1418.                 8:   Get_Terminal_Type;
  1419.                 9:   Get_Modem_Setup;
  1420.                10:   Get_Default_Transfer_Protocol;
  1421.                11:   Get_Kermit_Params;
  1422.                12:   Get_Screen_Dump_Name;
  1423.                13:   Get_Video_Mode_And_Colors;
  1424.                14:   Get_Miscellaneous;
  1425.                15:   Read_In_Script := TRUE;
  1426.                16:   Write_Config_File;
  1427.                ELSE;
  1428.  
  1429.             END (* CASE *);
  1430.                                    (* Remember if comm parms changed *)
  1431.  
  1432.             Reset_Comm_Port := Reset_Comm_Port OR ( Settings_Choice <= 5 );
  1433.  
  1434.          UNTIL ( Settings_Choice = 17 ) OR
  1435.                  Script_File_Mode       OR
  1436.                  Read_In_Script;
  1437.  
  1438.       END;
  1439.  
  1440. END   (* Get_Default_Params *);
  1441.